import { Op, Transaction } from 'sequelize';
import sequelize from '@/config/database';
import User from '@/models/system/user.model';
import Role from '@/models/system/role.model';
import UserRole from '@/models/system/userRole.model';
import Post from '@/models/system/post.model';
import UserPost from '@/models/system/userPost.model';
import { PaginationParams } from '@/types';
import { getLogger } from '@/utils/logger';
import Dept from '@/models/system/dept.model';


const logger = getLogger("user-service", {
	console: false,
});
const consoleLogger = getLogger("user-service");

// 用户查询参数接口
export interface UserQueryParams extends PaginationParams {
  userName?: string;
  phonenumber?: string;
  status?: string;
  deptId?: number;
  beginTime?: string;
  endTime?: string;
}

// 用户创建参数接口
export interface UserCreateParams {
  userName: string;
  nickName?: string;
  password: string;
  deptId?: number;
  email?: string;
  phonenumber?: string;
  sex?: string;
  status?: string;
  remark?: string;
  postIds?: number[];
  roleIds?: number[];
  createBy?: string;
}

// 用户服务类
class UserService {
  /**
   * 查询用户列表（分页、条件、部门递归、角色/部门关联）
   * @param params 查询参数
   */
  async getUserList(params: UserQueryParams) {
    try {
      const { pageNum = 1, pageSize = 10, userName, status, phonenumber, deptId, beginTime, endTime } = params;
      
      // 使用consoleLogger记录重要操作的开始
      consoleLogger.info(`查询用户列表: 页码=${pageNum}, 每页=${pageSize}${userName ? ', 用户名=' + userName : ''}${status ? ', 状态=' + status : ''}${deptId ? ', 部门ID=' + deptId : ''}`);
      
      // 构建基础查询条件
      const whereConditions: any = {
        delFlag: '0'
      };
      // 用户名模糊查询
      if (userName) {
        whereConditions.userName = { [Op.like]: `%${userName}%` };
      }
      // 状态精确查询
      if (status) {
        whereConditions.status = status;
      }
      // 手机号模糊查询
      if (phonenumber) {
        whereConditions.phonenumber = { [Op.like]: `%${phonenumber}%` };
      }
      // 部门及其子部门递归查询
      if (deptId) {
        const dept = await Dept.findByPk(deptId);
        if (dept) {
          // 查询所有子部门ID
          const childDepts = await Dept.findAll({
            where: {
              [Op.or]: [
                { ancestors: { [Op.like]: `%,${deptId},%` } },
                { ancestors: { [Op.like]: `${deptId},%` } },
                { ancestors: { [Op.like]: `%,${deptId}` } }
              ]
            },
            attributes: ['deptId']
          });
          const deptIds = [deptId, ...childDepts.map(dept => dept.deptId)];
          whereConditions.deptId = { [Op.in]: deptIds };
        }
      }
      // 创建时间范围查询
      if (beginTime && endTime) {
        whereConditions.createTime = {
          [Op.between]: [beginTime, endTime]
        };
      }
      // 分页参数处理
      const parsedPageNum = typeof pageNum === 'string' ? parseInt(pageNum, 10) : pageNum;
      const parsedPageSize = typeof pageSize === 'string' ? parseInt(pageSize, 10) : pageSize;
      // 执行分页查询，包含角色和部门信息
      const { count, rows } = await User.findAndCountAll({
        where: whereConditions,
        attributes: { exclude: ['password'] },
        include: [
          {
            model: Role,
            through: { attributes: [] },
            required: false,
            as: 'roles'
          },
          {
            model: Dept,
            as: 'dept',
            attributes: [
              'deptId', 'parentId', 'ancestors', 'deptName', 'orderNum',
              'leader', 'phone', 'email', 'status', 'delFlag',
              'createBy', 'createTime', 'updateBy', 'updateTime'
            ]
          }
        ],
        offset: (parsedPageNum - 1) * parsedPageSize,
        limit: parsedPageSize,
        order: [['createTime', 'DESC']]
      });
      // 处理返回数据结构，统一前端所需字段
      const processedRows = rows.map(user => {
        const userData = user.toJSON();
        userData.admin = userData.roles?.some(role => role.roleKey === 'admin') || false;
        userData.roleIds = userData.roles?.map(role => role.roleId) || [];
        userData.postIds = userData.posts?.map(post => post.postId) || [];
        userData.roleId = userData.roles?.[0]?.roleId || null;
        return userData;
      });
      
      // 使用logger记录详细的结果信息
      logger.info(`用户列表查询完成: 总数=${count}, 页码=${parsedPageNum}, 每页=${parsedPageSize}`);
      
      return {
        total: count,
        rows: processedRows,
        pageNum: parsedPageNum,
        pageSize: parsedPageSize
      };
    } catch (error) {
      // 错误情况只用consoleLogger，确保在控制台可见
      consoleLogger.error(`查询用户列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询用户列表失败');
    }
  }
  
  /**
   * 查询已分配指定角色的用户列表
   * @param params 查询参数
   * @param roleId 角色ID
   */
  async getAllocatedUserList(params: UserQueryParams, roleId: number) {
    try {
      const { pageNum = 1, pageSize = 10, userName, phonenumber } = params;
      
      logger.debug(`查询已分配角色的用户列表: roleId=${roleId}, 页码=${pageNum}, 每页=${pageSize}`);
      
      // 构建基础查询条件
      const whereConditions: any = {
        delFlag: '0'
      };
      if (userName) {
        whereConditions.userName = { [Op.like]: `%${userName}%` };
      }
      if (phonenumber) {
        whereConditions.phonenumber = { [Op.like]: `%${phonenumber}%` };
      }
      // 查询已分配指定角色的用户
      const { count, rows } = await User.findAndCountAll({
        where: whereConditions,
        include: [
          {
            model: Role,
            where: { roleId },
            through: { attributes: [] },
            required: true
          }
        ],
        attributes: { exclude: ['password'] },
        offset: (pageNum - 1) * pageSize,
        limit: pageSize,
        distinct: true,
        order: [['createTime', 'DESC']]
      });
      
      logger.debug(`查询已分配角色的用户列表完成: roleId=${roleId}, 总数=${count}`);
      
      return {
        total: count,
        rows,
        pageNum,
        pageSize
      };
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`查询已分配角色的用户列表失败: roleId=${roleId}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询已分配用户角色列表失败');
    }
  }
  
  /**
   * 查询未分配指定角色的用户列表（不使用原始SQL，纯Sequelize实现）
   * @param params 查询参数
   * @param roleId 角色ID
   */
  async getUnallocatedUserList(params: UserQueryParams, roleId: number) {
    try {
      const { pageNum = 1, pageSize = 10, userName, phonenumber } = params;
      
      logger.debug(`查询未分配角色的用户列表: roleId=${roleId}, 页码=${pageNum}, 每页=${pageSize}`);
      
      // 查询所有已分配该角色的用户ID
      const allocatedUserRoles = await UserRole.findAll({
        where: { roleId },
        attributes: ['userId']
      });
      const allocatedUserIds = allocatedUserRoles.map(ur => ur.userId);
      
      // 构建查询条件
      const whereConditions: any = {
        delFlag: '0',
      };
      if (allocatedUserIds.length > 0) {
        // 未分配的用户 = 不在已分配用户ID列表中
        whereConditions.userId = { [Op.notIn]: allocatedUserIds };
      }
      if (userName) {
        whereConditions.userName = { [Op.like]: `%${userName}%` };
      }
      if (phonenumber) {
        whereConditions.phonenumber = { [Op.like]: `%${phonenumber}%` };
      }
      
      // 分页查询
      const { count, rows } = await User.findAndCountAll({
        where: whereConditions,
        attributes: { exclude: ['password'] },
        offset: (pageNum - 1) * pageSize,
        limit: pageSize,
        order: [['createTime', 'DESC']]
      });
      
      logger.debug(`查询未分配角色的用户列表完成: roleId=${roleId}, 总数=${count}`);
      
      return {
        total: count,
        rows,
        pageNum,
        pageSize
      };
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`查询未分配角色的用户列表失败: roleId=${roleId}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询未分配用户角色列表失败');
    }
  }
  
  /**
   * 获取所有角色列表
   */
  async getAllRoles() {
    try {
      logger.debug('查询所有角色列表');
      
      const roles = await Role.findAll({
        where: {
          delFlag: '0'
        },
        attributes: [
          'roleId', 'roleName', 'roleKey', 'roleSort', 'dataScope',
          'menuCheckStrictly', 'deptCheckStrictly', 'status', 'delFlag',
          'createBy', 'createTime', 'updateBy', 'updateTime', 'remark'
        ]
      });
      
      logger.debug(`查询所有角色列表完成: 数量=${roles.length}`);
      return roles;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`获取角色列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取角色列表失败');
    }
  }

  /**
   * 获取所有岗位列表
   */
  async getAllPosts() {
    try {
      logger.debug('查询所有岗位列表');
      
      const posts = await Post.findAll({
        attributes: [
          'postId', 'postCode', 'postName', 'postSort', 'status',
          'createBy', 'createTime', 'updateBy', 'updateTime', 'remark'
        ]
      });
      
      logger.debug(`查询所有岗位列表完成: 数量=${posts.length}`);
      return posts;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`获取岗位列表失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('获取岗位列表失败');
    }
  }

  /**
   * 根据用户ID查询用户详细信息，包含角色、岗位、部门等
   * @param userId 用户ID
   */
  async getUserById(userId: number) {
    try {
      logger.debug(`根据ID查询用户详细信息: userId=${userId}`);
      
      const user = await User.findOne({
        where: {
          userId,
          delFlag: '0'
        },
        attributes: { exclude: ['password'] },
        include: [
          {
            model: Role,
            through: { attributes: [] },
            as: 'roles',
            attributes: [
              'roleId', 'roleName', 'roleKey', 'roleSort', 'dataScope',
              'menuCheckStrictly', 'deptCheckStrictly', 'status', 'delFlag',
              'createBy', 'createTime', 'updateBy', 'updateTime', 'remark'
            ]
          },
          {
            model: Post,
            through: { attributes: [] },
            as: 'posts',
            attributes: [
              'postId', 'postCode', 'postName', 'postSort', 'status',
              'createBy', 'createTime', 'updateBy', 'updateTime', 'remark'
            ]
          },
          {
            model: Dept,
            as: 'dept',
            attributes: [
              'deptId', 'parentId', 'ancestors', 'deptName', 'orderNum',
              'leader', 'phone', 'email', 'status', 'delFlag',
              'createBy', 'createTime', 'updateBy', 'updateTime'
            ]
          }
        ]
      });
      
      if (user) {
        const userData = user.toJSON();
        // 设置admin标志
        userData.admin = userData.roles?.some(role => role.roleKey === 'admin') || false;
        // 设置roleIds
        const roleIds = userData.roles?.map(role => role.roleId) || [];
        userData.roleIds = roleIds;
        // 设置postIds
        const postIds = userData.posts?.map(post => post.postId) || [];
        userData.postIds = postIds;
        // 设置roleId
        userData.roleId = userData.roles?.[0]?.roleId || null;
        
        // 获取所有角色和岗位
        const [allRoles, allPosts] = await Promise.all([
          this.getAllRoles(),
          this.getAllPosts()
        ]);
        
        // 为每个岗位添加flag字段，标记用户是否拥有该岗位
        const posts = allPosts.map(post => ({
          ...post.toJSON(),
          flag: postIds.includes(post.postId)
        }));
        
        // 为每个角色添加flag字段，标记用户是否拥有该角色
        const roles = allRoles.map(role => ({
          ...role.toJSON(),
          flag: roleIds.includes(role.roleId),
          menuIds: null,
          deptIds: null,
          permissions: null
        }));
        
        // 为部门添加children字段
        if (userData.dept) {
          userData.dept = {
            ...userData.dept,
            parentName: null,
            children: []
          };
        }
        
        logger.debug(`根据ID查询用户详细信息完成: userId=${userId}`);
        return {
          msg: '操作成功',
          code: 200,
          roleIds,
          data: userData,
          postIds,
          roles,
          posts
        };
      }
      
      logger.debug(`根据ID查询用户详细信息: 用户不存在 userId=${userId}`);
      return null;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`根据ID查询用户失败: userId=${userId}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询用户信息失败');
    }
  }
  
  /**
   * 根据用户名查询用户信息（含角色）
   * @param userName 用户名
   */
  async getUserByUserName(userName: string) {
    try {
      logger.debug(`根据用户名查询用户: userName=${userName}`);
      
      return User.findOne({
        where: {
          userName,
          delFlag: '0'
        },
        include: [
          {
            model: Role,
            through: { attributes: [] }
          }
        ]
      });
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`根据用户名查询用户失败: userName=${userName}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('查询用户信息失败');
    }
  }
  
  /**
   * 校验用户名是否唯一
   * @param userName 用户名
   * @param userId 用户ID (更新时传入)
   */
  async checkUserNameUnique(userName: string, userId?: number): Promise<boolean> {
    try {
      logger.debug(`校验用户名唯一性: userName=${userName}${userId ? ', userId=' + userId : ''}`);
      
      const whereConditions: any = {
        userName,
        delFlag: '0'
      };
      if (userId) {
        whereConditions.userId = { [Op.ne]: userId };
      }
      const count = await User.count({ where: whereConditions });
      const isUnique = count === 0;
      
      logger.debug(`校验用户名唯一性结果: userName=${userName}, 唯一=${isUnique}`);
      return isUnique;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`校验用户名唯一性失败: userName=${userName}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('校验用户名唯一性失败');
    }
  }
  
  /**
   * 校验手机号是否唯一
   * @param phonenumber 手机号
   * @param userId 用户ID (更新时传入)
   */
  async checkPhoneUnique(phonenumber: string, userId?: number): Promise<boolean> {
    try {
      logger.debug(`校验手机号唯一性: phone=${phonenumber}${userId ? ', userId=' + userId : ''}`);
      
      const whereConditions: any = {
        phonenumber,
        delFlag: '0'
      };
      if (userId) {
        whereConditions.userId = { [Op.ne]: userId };
      }
      const count = await User.count({ where: whereConditions });
      const isUnique = count === 0;
      
      logger.debug(`校验手机号唯一性结果: phone=${phonenumber}, 唯一=${isUnique}`);
      return isUnique;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`校验手机号唯一性失败: phone=${phonenumber}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('校验手机号唯一性失败');
    }
  }
  
  /**
   * 校验邮箱是否唯一
   * @param email 邮箱
   * @param userId 用户ID (更新时传入)
   */
  async checkEmailUnique(email: string, userId?: number): Promise<boolean> {
    try {
      logger.debug(`校验邮箱唯一性: email=${email}${userId ? ', userId=' + userId : ''}`);
      
      const whereConditions: any = {
        email,
        delFlag: '0'
      };
      if (userId) {
        whereConditions.userId = { [Op.ne]: userId };
      }
      const count = await User.count({ where: whereConditions });
      const isUnique = count === 0;
      
      logger.debug(`校验邮箱唯一性结果: email=${email}, 唯一=${isUnique}`);
      return isUnique;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`校验邮箱唯一性失败: email=${email}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('校验邮箱唯一性失败');
    }
  }
  
  /**
   * 新增用户（含岗位、角色关联，事务处理）
   * @param userData 用户数据
   * @param operator 操作人
   */
  async createUser(userData: UserCreateParams, operator: string) {
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`创建用户: ${userData.userName}, 操作人: ${operator}`);
    
    const transaction = await sequelize.transaction();
    try {
      userData.createBy = operator;
      
      // 创建用户
      const user = await User.create(userData, { transaction });
      // 使用logger记录详细的业务流程
      logger.info(`用户基本信息创建成功, userId=${user.userId}`);
      
      // 创建用户岗位关联
      if (userData.postIds && userData.postIds.length > 0) {
        const userPosts = userData.postIds.map(postId => ({
          userId: user.userId,
          postId
        }));
        await UserPost.bulkCreate(userPosts, { transaction });
        logger.info(`用户岗位关联创建成功, userId=${user.userId}, 岗位数量=${userData.postIds.length}`);
      }
      
      // 创建用户角色关联
      if (userData.roleIds && userData.roleIds.length > 0) {
        const userRoles = userData.roleIds.map(roleId => ({
          userId: user.userId,
          roleId
        }));
        await UserRole.bulkCreate(userRoles, { transaction });
        logger.info(`用户角色关联创建成功, userId=${user.userId}, 角色数量=${userData.roleIds.length}`);
      }
      
      await transaction.commit();
      // 重要操作完成，使用consoleLogger
      consoleLogger.info(`用户 ${userData.userName}(${user.userId}) 创建完成`);
      
      return user;
    } catch (error) {
      await transaction.rollback();
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`新增用户 ${userData.userName} 失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('新增用户失败');
    }
  }
  
  /**
   * 修改用户（含岗位、角色关联，事务处理）
   * @param userId 用户ID
   * @param userData 用户数据
   * @param operator 操作人
   */
  async updateUser(userId: number, userData: any, operator: string) {
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`更新用户: ID=${userId}, 操作人: ${operator}`);
    
    const transaction = await sequelize.transaction();
    try {
      // 查询用户是否存在
      const user = await User.findByPk(userId, { transaction });
      if (!user) {
        consoleLogger.warn(`用户不存在: ID=${userId}`);
        throw new Error('用户不存在');
      }
      
      userData.updateBy = operator;
      userData.updateTime = new Date();
      
      // 更新用户信息
      await user.update(userData, { transaction });
      logger.info(`用户基本信息更新成功: ID=${userId}`);
      
      // 更新用户岗位关联
      if (userData.postIds) {
        await UserPost.destroy({ where: { userId }, transaction });
        logger.info(`用户岗位关联已删除: ID=${userId}`);
        
        if (userData.postIds.length > 0) {
          const userPosts = userData.postIds.map((postId: number) => ({ userId, postId }));
          await UserPost.bulkCreate(userPosts, { transaction });
          logger.info(`用户岗位关联重建成功: ID=${userId}, 岗位数量=${userData.postIds.length}`);
        }
      }
      
      // 更新用户角色关联
      if (userData.roleIds) {
        await UserRole.destroy({ where: { userId }, transaction });
        logger.info(`用户角色关联已删除: ID=${userId}`);
        
        if (userData.roleIds.length > 0) {
          const userRoles = userData.roleIds.map((roleId: number) => ({ userId, roleId }));
          await UserRole.bulkCreate(userRoles, { transaction });
          logger.info(`用户角色关联重建成功: ID=${userId}, 角色数量=${userData.roleIds.length}`);
        }
      }
      
      await transaction.commit();
      // 重要操作完成，使用consoleLogger
      consoleLogger.info(`用户 ID=${userId} 更新完成`);
      
      return user;
    } catch (error) {
      await transaction.rollback();
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`修改用户 ID=${userId} 失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('修改用户失败');
    }
  }
  
  /**
   * 删除用户（逻辑删除，事务处理）
   * @param userIds 用户ID数组
   * @param operator 操作人
   */
  async deleteUsers(userIds: number[], operator: string) {
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`删除用户: IDs=${userIds.join(',')}, 操作人: ${operator}`);
    
    const transaction = await sequelize.transaction();
    try {
      // 逻辑删除用户
      const result = await User.update(
        {
          delFlag: '2',
          updateBy: operator,
          updateTime: new Date()
        },
        {
          where: {
            userId: {
              [Op.in]: userIds
            }
          },
          transaction
        }
      );
      
      await transaction.commit();
      // 重要操作完成，使用consoleLogger
      consoleLogger.info(`删除用户完成: IDs=${userIds.join(',')}, 影响行数=${result[0]}`);
      
      return result;
    } catch (error) {
      await transaction.rollback();
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`删除用户失败: IDs=${userIds.join(',')}, ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('删除用户失败');
    }
  }
  
  /**
   * 重置用户密码
   * @param userId 用户ID
   * @param password 新密码
   * @param operator 操作人
   */
  async resetPassword(userId: number, password: string, operator: string) {
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`重置用户密码: ID=${userId}, 操作人: ${operator}`);
    
    try {
      const user = await User.findByPk(userId);
      if (!user) {
        consoleLogger.warn(`用户不存在: ID=${userId}`);
        throw new Error('用户不存在');
      }
      
      const result = await user.update({
        password,
        updateBy: operator,
        updateTime: new Date()
      });
      
      // 重要操作完成，使用consoleLogger
      consoleLogger.info(`用户密码重置完成: ID=${userId}`);
      
      return result;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`重置用户 ID=${userId} 密码失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('重置密码失败');
    }
  }
  
  /**
   * 修改用户状态
   * @param userId 用户ID
   * @param status 状态
   * @param operator 操作人
   */
  async changeUserStatus(userId: number, status: string, operator: string) {
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`修改用户状态: ID=${userId}, 状态=${status}, 操作人: ${operator}`);
    
    try {
      const user = await User.findByPk(userId);
      if (!user) {
        consoleLogger.warn(`用户不存在: ID=${userId}`);
        throw new Error('用户不存在');
      }
      
      const result = await user.update({
        status,
        updateBy: operator,
        updateTime: new Date()
      });
      
      // 重要操作完成，使用consoleLogger
      consoleLogger.info(`用户状态修改完成: ID=${userId}, 状态=${status}`);
      
      return result;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`修改用户 ID=${userId} 状态失败: ${error instanceof Error ? error.message : String(error)}`);
      throw new Error('修改用户状态失败');
    }
  }
  
  /**
   * 批量导入用户数据，支持更新，事务处理
   * @param userList 用户数据列表
   * @param updateSupport 是否支持更新
   * @param operator 操作人
   */
  async importUser(userList: any[], updateSupport: boolean, operator: string): Promise<string> {
    if (!userList || userList.length === 0) {
      throw new Error('导入用户数据不能为空');
    }
    
    // 重要操作的开始，使用consoleLogger
    consoleLogger.info(`批量导入用户: 数量=${userList.length}, 支持更新=${updateSupport}, 操作人: ${operator}`);
    
    let successCount = 0;
    let failureCount = 0;
    const failureMessages: string[] = [];
    
    // 并发处理所有用户数据
    await Promise.all(userList.map(async (userData) => {
      if (!userData.userName || !userData.password) {
        failureCount++;
        failureMessages.push(`用户 ${userData.userName || '未知用户'} 导入失败：用户名和密码不能为空`);
        return;
      }
      try {
        // 校验用户名是否存在
        const existingUser = await User.findOne({
          where: { userName: userData.userName, delFlag: '0' }
        });
        let transaction: Transaction | null = null;
        
        // 用户存在且支持更新
        if (existingUser && updateSupport) {
          transaction = await sequelize.transaction();
          try {
            const updateData = {
              ...userData,
              updateBy: operator,
              updateTime: new Date()
            };
            delete updateData.password; // 不更新密码
            await existingUser.update(updateData, { transaction });
            
            // 岗位关联
            if (userData.postIds && userData.postIds.length > 0) {
              await UserPost.destroy({ where: { userId: existingUser.userId }, transaction });
              const userPosts = userData.postIds.map((postId: number) => ({ userId: existingUser.userId, postId }));
              await UserPost.bulkCreate(userPosts, { transaction });
            }
            
            // 角色关联
            if (userData.roleIds && userData.roleIds.length > 0) {
              await UserRole.destroy({ where: { userId: existingUser.userId }, transaction });
              const userRoles = userData.roleIds.map((roleId: number) => ({ userId: existingUser.userId, roleId }));
              await UserRole.bulkCreate(userRoles, { transaction });
            }
            
            await transaction.commit();
            logger.info(`更新用户成功: ${userData.userName}(${existingUser.userId})`);
            successCount++;
          } catch (error) {
            if (transaction) await transaction.rollback();
            failureCount++;
            logger.error(`更新用户失败: ${userData.userName}, ${error instanceof Error ? error.message : String(error)}`);
            failureMessages.push(`用户 ${userData.userName} 更新失败：${error instanceof Error ? error.message : String(error)}`);
          }
        } else if (!existingUser) {
          // 用户不存在则新增
          await this.createUser({ ...userData, createBy: operator }, operator);
          successCount++;
        } else {
          // 用户存在但不支持更新
          failureCount++;
          logger.warn(`用户已存在且不支持更新: ${userData.userName}`);
          failureMessages.push(`用户 ${userData.userName} 已存在，未进行更新`);
        }
      } catch (error) {
        failureCount++;
        logger.error(`导入用户失败: ${userData.userName || '未知用户'}, ${error instanceof Error ? error.message : String(error)}`);
        failureMessages.push(`用户 ${userData.userName || '未知用户'} 导入失败：${error instanceof Error ? error.message : String(error)}`);
      }
    }));
    
    // 记录导入结果，重要操作完成，使用consoleLogger
    const resultMessage = `导入成功 ${successCount} 条，失败 ${failureCount} 条${failureCount > 0 ? '，失败原因：' + failureMessages.join('；') : ''}`;
    consoleLogger.info(`批量导入用户完成: ${resultMessage}`);
    
    // 返回导入结果
    return resultMessage;
  }
  
  /**
   * 查询用户所属角色组（逗号分隔）
   * @param userName 用户名
   */
  async selectUserRoleGroup(userName: string): Promise<string> {
    try {
      logger.debug(`查询用户角色组: userName=${userName}`);
      
      const user = await User.findOne({
        where: { userName, delFlag: '0' },
        include: [
          {
            model: Role,
            through: { attributes: [] },
            as: 'roles'
          }
        ]
      });
      
      if (!user) {
        logger.debug(`查询用户角色组: 用户不存在 userName=${userName}`);
        return '';
      }
      
      const userWithRoles = user as any;
      if (!userWithRoles.roles || userWithRoles.roles.length === 0) {
        logger.debug(`查询用户角色组: 用户没有角色 userName=${userName}`);
        return '';
      }
      
      const roleNames = userWithRoles.roles.map((role: any) => role.roleName).join(',');
      logger.debug(`查询用户角色组成功: userName=${userName}, 角色=${roleNames}`);
      return roleNames;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`查询用户角色组失败: ${userName}, ${error instanceof Error ? error.message : String(error)}`);
      return '';
    }
  }
  
  /**
   * 查询用户所属岗位组（逗号分隔）
   * @param userName 用户名
   */
  async selectUserPostGroup(userName: string): Promise<string> {
    try {
      logger.debug(`查询用户岗位组: userName=${userName}`);
      
      const user = await User.findOne({
        where: { userName, delFlag: '0' },
        include: [
          {
            model: Post,
            through: { attributes: [] },
            as: 'posts'
          }
        ]
      });
      
      if (!user) {
        logger.debug(`查询用户岗位组: 用户不存在 userName=${userName}`);
        return '';
      }
      
      const userWithPosts = user as any;
      if (!userWithPosts.posts || userWithPosts.posts.length === 0) {
        logger.debug(`查询用户岗位组: 用户没有岗位 userName=${userName}`);
        return '';
      }
      
      const postNames = userWithPosts.posts.map((post: any) => post.postName).join(',');
      logger.debug(`查询用户岗位组成功: userName=${userName}, 岗位=${postNames}`);
      return postNames;
    } catch (error) {
      // 错误只用consoleLogger，确保在控制台可见
      consoleLogger.error(`查询用户岗位组失败: ${userName}, ${error instanceof Error ? error.message : String(error)}`);
      return '';
    }
  }

  /**
   * 更新用户个人信息
   * @param userId 用户ID
   * @param userData 用户数据
   * @param operator 操作人
   */
  async updateUserProfile(userId: number, userData: any, operator: string) {
    try {
      // 记录操作开始
      consoleLogger.info(`更新用户个人信息: userId=${userId}, operator=${operator}`);
      
      // 从userData中提取需要更新的个人信息字段
      const { nickName, sex, email, phonenumber, avatar } = userData;
      
      // 构建更新对象，只包含个人信息相关字段
      const updateData: any = {
        updateBy: operator,
        updateTime: new Date()
      };
      
      // 只更新提供的字段
      if (nickName !== undefined) updateData.nickName = nickName;
      if (sex !== undefined) updateData.sex = sex;
      if (email !== undefined) updateData.email = email;
      if (phonenumber !== undefined) updateData.phonenumber = phonenumber;
      if (avatar !== undefined) updateData.avatar = avatar;
      
      // 执行更新操作
      const [affectedCount] = await User.update(updateData, {
        where: { userId }
      });
      
      if (affectedCount === 0) {
        throw new Error('更新用户个人信息失败，用户不存在');
      }
      
      // 记录操作结果
      logger.info(`更新用户个人信息成功: userId=${userId}, operator=${operator}`);
      
      return true;
    } catch (error) {
      // 记录错误
      consoleLogger.error(`更新用户个人信息失败: ${error instanceof Error ? error.message : String(error)}`);
      throw error;
    }
  }

  /**
   * 更新用户个人密码
   * @param userId 用户ID
   * @param oldPassword 旧密码
   * @param newPassword 新密码
   * @param operator 操作人
   */
  async updatePassword(userId: number, oldPassword: string, newPassword: string, operator: string) {
    try {
      // 记录操作开始
      consoleLogger.info(`更新用户个人密码: userId=${userId}, operator=${operator}`);
      
      // 查询用户
      const user = await User.findByPk(userId);
      if (!user) {
        throw new Error('用户不存在');
      }
      
      // 校验旧密码是否正确
      if (!user.validatePassword(oldPassword)) {
        throw new Error('旧密码不正确');
      }
      
      // 校验新密码与旧密码是否相同
      if (user.validatePassword(newPassword)) {
        throw new Error('新密码不能与旧密码相同');
      }
      
      // 更新密码
      user.password = newPassword;
      user.updateBy = operator;
      user.updateTime = new Date();
      await user.save();
      
      // 记录操作结果
      logger.info(`更新用户个人密码成功: userId=${userId}, operator=${operator}`);
      
      return true;
    } catch (error) {
      // 记录错误
      consoleLogger.error(`更新用户个人密码失败: ${error instanceof Error ? error.message : String(error)}`);
      throw error;
    }
  }

  /**
   * 更新用户头像
   * @param userId 用户ID
   * @param avatar 头像路径
   * @param operator 操作人
   */
  async updateUserAvatar(userId: number, avatar: string, operator: string) {
    try {
      // 记录操作开始
      consoleLogger.info(`更新用户头像: userId=${userId}, avatar=${avatar}, operator=${operator}`);
      
      // 构建更新对象
      const updateData: any = {
        avatar,
        updateBy: operator,
        updateTime: new Date()
      };
      
      // 执行更新操作
      const [affectedCount] = await User.update(updateData, {
        where: { userId }
      });
      
      if (affectedCount === 0) {
        throw new Error('更新用户头像失败，用户不存在');
      }
      
      // 记录操作结果
      logger.info(`更新用户头像成功: userId=${userId}, operator=${operator}`);
      
      return true;
    } catch (error) {
      // 记录错误
      consoleLogger.error(`更新用户头像失败: ${error instanceof Error ? error.message : String(error)}`);
      throw error;
    }
  }
}

export default new UserService();